home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / pyshared / UpdateManager / ChangelogViewer.py < prev    next >
Encoding:
Python Source  |  2009-04-27  |  10.5 KB  |  264 lines
  1. # ReleaseNotesViewer.py
  2. #  
  3. #  Copyright (c) 2006 Sebastian Heinlein
  4. #                2007 Canonical
  5. #  
  6. #  Author: Sebastian Heinlein <sebastian.heinlein@web.de>
  7. #          Michael Vogt <michael.vogt@ubuntu.com>
  8. #
  9. #  This modul provides an inheritance of the gtk.TextView that is 
  10. #  aware of http URLs and allows to open them in a browser.
  11. #  It is based on the pygtk-demo "hypertext".
  12. # 
  13. #  This program is free software; you can redistribute it and/or 
  14. #  modify it under the terms of the GNU General Public License as 
  15. #  published by the Free Software Foundation; either version 2 of the
  16. #  License, or (at your option) any later version.
  17. # 
  18. #  This program is distributed in the hope that it will be useful,
  19. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21. #  GNU General Public License for more details.
  22. # 
  23. #  You should have received a copy of the GNU General Public License
  24. #  along with this program; if not, write to the Free Software
  25. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  26. #  USA
  27.  
  28.  
  29. import pygtk
  30. import gtk
  31. import pango
  32. import subprocess
  33. import os
  34. from gettext import gettext as _
  35.  
  36. class ChangelogViewer(gtk.TextView):
  37.     def __init__(self, changelog=None):
  38.         """Init the ChangelogViewer as an Inheritance of the gtk.TextView"""
  39.         # init the parent
  40.         gtk.TextView.__init__(self)
  41.         # global hovering over link state
  42.         self.hovering = False
  43.         self.first = True
  44.         # setup the buffer and signals
  45.         self.set_property("editable", False)
  46.         self.set_cursor_visible(False)
  47.         # set some margin
  48.         self.set_right_margin(4)
  49.         self.set_left_margin(4)
  50.         self.set_pixels_above_lines(4)
  51.         self.buffer = gtk.TextBuffer()
  52.         self.set_buffer(self.buffer)
  53.         self.connect("button-press-event", self.button_press_event)
  54.         self.connect("motion-notify-event", self.motion_notify_event)
  55.         self.connect("visibility-notify-event", self.visibility_notify_event)
  56.         #self.buffer.connect("changed", self.search_links)
  57.         self.buffer.connect_after("insert-text", self.on_insert_text)
  58.         # search for links in the changelog and make them clickable
  59.         if changelog != None:
  60.             self.buffer.set_text(changelog)
  61.             
  62.     def create_context_menu(self, url):
  63.         """Create the context menu to be displayed when links are right clicked"""
  64.         self.menu = gtk.Menu()
  65.         
  66.         # create menu items
  67.         item_grey_link = gtk.MenuItem(url)
  68.         item_grey_link.connect("activate", self.handle_context_menu, "open", url)
  69.         item_seperator = gtk.MenuItem()
  70.         item_open_link = gtk.MenuItem(_("Open Link in Browser"))
  71.         item_open_link.connect("activate", self.handle_context_menu, "open", url)
  72.         item_copy_link = gtk.MenuItem(_("Copy Link to Clipboard"))
  73.         item_copy_link.connect("activate", self.handle_context_menu, "copy", url)
  74.         
  75.         # add menu items
  76.         self.menu.add(item_grey_link)
  77.         self.menu.add(item_seperator)
  78.         self.menu.add(item_open_link)
  79.         self.menu.add(item_copy_link)
  80.         self.menu.show_all()
  81.     
  82.     def handle_context_menu(self, menuitem, action, url):
  83.         """Handle activate event for the links' context menu"""
  84.         if action == "open":
  85.             self.open_url(url)
  86.         if action == "copy":
  87.             cb = gtk.Clipboard()
  88.             cb.set_text(url)
  89.             cb.store()
  90.  
  91.     def tag_link(self, start, end, url):
  92.         """Apply the tag that marks links to the specified buffer selection"""
  93.         tagged = False
  94.         tags = start.get_tags()
  95.         for tag in tags:
  96.             url = tag.get_data("url")
  97.             if url != "":
  98.                 return
  99.         tag = self.buffer.create_tag(None, foreground="blue",
  100.                                      underline=pango.UNDERLINE_SINGLE)
  101.         tag.set_data("url", url)
  102.         self.buffer.apply_tag(tag , start, end)
  103.  
  104.     def on_insert_text(self, buffer, iter_end, text, *args):
  105.         """Search for http URLs in newly inserted text  
  106.            and tag them accordingly"""
  107.  
  108.         # some convenient urls
  109.         MALONE = "https://launchpad.net/bugs/"
  110.         DEBIAN = "http://bugs.debian.org/"
  111.         CVE = "http://cve.mitre.org/cgi-bin/cvename.cgi?name="
  112.         # some convinient end-markers
  113.         ws = [" ","\t","\n"]
  114.         brak = [")","]",">"]
  115.         punct = [",","!",":"]
  116.         dot = ["."]+punct
  117.         # search items are start-str, list-of-end-strs, url-prefix
  118.         # a lot of this search is "TEH SUCK"(tm) because of limitations
  119.         # in iter.forward_search()
  120.         # - i.e. no insensitive searching, no regexp
  121.         search_items = [ ("http://", ws+brak+punct, "http://"),
  122.                          ("LP#", ws+brak+dot, MALONE),
  123.                          ("LP: #", ws+brak+dot, MALONE),
  124.                          ("lp: #", ws+brak+dot, MALONE),
  125.                          ("LP:#",  ws+brak+dot, MALONE),
  126.                          ("Malone: #", ws+brak+dot, MALONE),
  127.                          ("Malone:#", ws+brak+dot, MALONE),
  128.                          ("Ubuntu: #", ws+brak+dot, MALONE),
  129.                          ("Ubuntu:#", ws+brak+dot, MALONE),
  130.                          ("Closes: #",ws+brak+dot, DEBIAN),
  131.                          ("Closes:#",ws+brak+dot, DEBIAN),
  132.                          ("closes:#",ws+brak+dot, DEBIAN),
  133.                          ("closes: #",ws+brak+dot, DEBIAN),
  134.                          ("CVE-", ws+brak+dot, CVE),
  135.                        ]
  136.         # init
  137.         iter = buffer.get_iter_at_offset(iter_end.get_offset() - len(text))
  138.         iter_real_end = buffer.get_end_iter()
  139.  
  140.         # search for the next match in the buffer
  141.         for (start_str, end_list, url_prefix) in search_items:
  142.             while True:
  143.                 ret = iter.forward_search(start_str,
  144.                                           gtk.TEXT_SEARCH_VISIBLE_ONLY,
  145.                                           iter_end)
  146.                 # if we reach the end break the loop
  147.                 if not ret:
  148.                     break
  149.                 # get the position of the protocol prefix
  150.                 (match_start, match_end) = ret
  151.                 match_suffix = match_end.copy()
  152.                 match_tmp = match_end.copy()
  153.                 while True:
  154.                     # extend the selection to the complete search item
  155.                     if match_tmp.forward_char():
  156.                         text =  match_end.get_text(match_tmp)
  157.                         if text in end_list:
  158.                             break
  159.                     else:
  160.                         break
  161.                     match_end = match_tmp.copy()
  162.  
  163.                 # call the tagging method for the complete URL
  164.                 url = url_prefix + match_suffix.get_text(match_end)
  165.  
  166.                 self.tag_link(match_start, match_end, url)
  167.                 # set the starting point for the next search
  168.                 iter = match_end
  169.  
  170.     def button_press_event(self, text_view, event):
  171.         """callback for mouse click events"""
  172.         # we only react on left or right mouse clicks
  173.         if event.button != 1 and event.button != 3:
  174.             return False
  175.  
  176.         # try to get a selection
  177.         try:
  178.             (start, end) = self.buffer.get_selection_bounds()
  179.         except ValueError:
  180.             pass
  181.         else:
  182.             if start.get_offset() != end.get_offset():
  183.                 return False
  184.  
  185.         # get the iter at the mouse position
  186.         (x, y) = self.window_to_buffer_coords(gtk.TEXT_WINDOW_WIDGET,
  187.                                               int(event.x), int(event.y))
  188.         iter = self.get_iter_at_location(x, y)
  189.         
  190.         # call open_url or menu.popup if an URL is assigned to the iter
  191.         tags = iter.get_tags()
  192.         for tag in tags:
  193.             url = tag.get_data("url")
  194.             if url != None:
  195.                 if event.button == 1: 
  196.                     self.open_url(url)
  197.                     break
  198.                 if event.button == 3:
  199.                     self.create_context_menu(url)
  200.                     self.menu.popup(None, None, None, event.button, event.time)
  201.                     return True
  202.  
  203.     def open_url(self, url):
  204.         """Open the specified URL in a browser"""
  205.         # Find an appropiate browser
  206.         if os.path.exists("/usr/bin/exo-open"):
  207.             command = ["exo-open", url]
  208.         elif os.path.exists('/usr/bin/gnome-open'):
  209.             command = ['gnome-open', url]
  210.         else:
  211.             command = ['x-www-browser', url]
  212.  
  213.         # Avoid to run the browser as user root
  214.         if os.getuid() == 0 and os.environ.has_key('SUDO_USER'):
  215.             command = ['sudo', '-u', os.environ['SUDO_USER']] + command
  216.  
  217.         subprocess.Popen(command)
  218.  
  219.     def motion_notify_event(self, text_view, event):
  220.         """callback for the mouse movement event, that calls the
  221.            check_hovering method with the mouse postition coordiantes"""
  222.         x, y = text_view.window_to_buffer_coords(gtk.TEXT_WINDOW_WIDGET,
  223.                                                  int(event.x), int(event.y))
  224.         self.check_hovering(x, y)
  225.         self.window.get_pointer()
  226.         return False
  227.     
  228.     def visibility_notify_event(self, text_view, event):
  229.         """callback if the widgets gets visible (e.g. moves to the foreground)
  230.            that calls the check_hovering method with the mouse position
  231.            coordinates"""
  232.         (wx, wy, mod) = text_view.window.get_pointer()
  233.         (bx, by) = text_view.window_to_buffer_coords(gtk.TEXT_WINDOW_WIDGET, wx,
  234.                                                      wy)
  235.         self.check_hovering(bx, by)
  236.         return False
  237.  
  238.     def check_hovering(self, x, y):
  239.         """Check if the mouse is above a tagged link and if yes show
  240.            a hand cursor"""
  241.         _hovering = False
  242.         # get the iter at the mouse position
  243.         iter = self.get_iter_at_location(x, y)
  244.         
  245.         # set _hovering if the iter has the tag "url"
  246.         tags = iter.get_tags()
  247.         for tag in tags:
  248.             url = tag.get_data("url")
  249.             if url != None:
  250.                 _hovering = True
  251.                 break
  252.  
  253.         # change the global hovering state
  254.         if _hovering != self.hovering or self.first == True:
  255.             self.first = False
  256.             self.hovering = _hovering
  257.             # Set the appropriate cursur icon
  258.             if self.hovering:
  259.                 self.get_window(gtk.TEXT_WINDOW_TEXT).\
  260.                         set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
  261.             else:
  262.                 self.get_window(gtk.TEXT_WINDOW_TEXT).\
  263.                         set_cursor(gtk.gdk.Cursor(gtk.gdk.LEFT_PTR))
  264.